// <copyright file="RhythmicMaterial.cs" company="Largo">
// Copyright (c) 2009 All Right Reserved
// </copyright>
// <author> vl </author>
// <email></email>
// <date>2009-01-01</date>
// <summary>Contains ...</summary>

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Text;
using System.Xml.Linq;
using JetBrains.Annotations;
using LargoCommon.Abstract;

namespace LargoCommon.Music
{
    /// <summary>  Musical material. </summary>
    /// <remarks> Musical class. </remarks>
    ////    [Serializable]
    [ContractVerification(false)]
    public sealed class RhythmicMaterial {
        #region Constructors
        /// <summary> Initializes a new instance of the RhythmicMaterial class. </summary>
        public RhythmicMaterial() {
            this.Structures = new List<RhythmicStructure>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RhythmicMaterial" /> class.
        /// </summary>
        /// <param name="xmaterial">The mark material.</param>
        public RhythmicMaterial(XElement xmaterial) {
            this.Name = XmlSupport.ReadStringAttribute(xmaterial.Attribute("Name"));
            this.RhythmicOrder = XmlSupport.ReadByteAttribute(xmaterial.Attribute("RhythmicOrder"));
            this.Structures = new List<RhythmicStructure>();

            var xstructs = xmaterial.Element("Structures");
            if (xstructs == null) {
                return;
            }

            foreach (var xstruct in xstructs.Elements()) {
                var rs = RhythmicSystem.GetRhythmicSystem(RhythmicDegree.Structure, this.RhythmicOrder);
                var code = XmlSupport.ReadStringAttribute(xstruct.Attribute("Code"));
                var structure = new RhythmicStructure(rs, code);
                this.Structures.Add(structure);
            }
        }
        #endregion

        #region Properties - Xml
        /// <summary> Gets Xml representation. </summary>
        /// <value> Property description. </value>
        public XElement GetXElement {
            get {
                XElement xmaterial = new XElement(
                    "RhythmicMaterial",
                    new XAttribute("Name", this.Name),
                    new XAttribute("RhythmicOrder", this.RhythmicOrder));

                //// Structures
                XElement xstructs = new XElement("Structures");
                foreach (RhythmicStructure structure in this.Structures) {
                    var xstruct = structure.GetXElement;
                    xstructs.Add(xstruct);
                }

                xmaterial.Add(xstructs);
                return xmaterial;
            }
        }
        #endregion

        #region Properties
        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The melodic order.
        /// </value>
        [UsedImplicitly]
        public string Name { get; set; }   //// CA1044 (FxCop)

        /// <summary>
        /// Gets or sets the rhythmic order.
        /// </summary>
        /// <value>
        /// The rhythmic order.
        /// </value>
        public byte RhythmicOrder { [UsedImplicitly] get; set; }

        /// <summary>
        /// Gets the structures.
        /// </summary>
        /// <value>
        /// The structures.
        /// </value>
        public IList<RhythmicStructure> Structures { get; }

        #endregion

        #region Rhythmic producer
        /// <summary>
        /// Random Rhythmic Materials.
        /// </summary>
        /// <param name="number">Number of material sets.</param>
        /// <param name="rhyStructs">Rhythmic Structs.</param>
        /// <param name="numberOfStructs">Number Of Structs.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        [UsedImplicitly]
        public static Collection<RhythmicMaterial> RandomRhythmicMaterials(int number, Collection<RhythmicStructure> rhyStructs, int numberOfStructs) {  //// byte rhythmicOrder,
            var coll = new Collection<RhythmicMaterial>();
            for (var i = 0; i < number; i++) {
                var name = string.Format(CultureInfo.CurrentCulture, "Automat ({0}) {1}", i.ToString(CultureInfo.CurrentCulture.NumberFormat).PadLeft(3), SupportCommon.DateTimeIdentifier);
                var rhyMaterial = RandomRhythmicMaterial(name, rhyStructs, numberOfStructs); //// rhythmicOrder,
                coll.Add(rhyMaterial);
            }

            return coll;
        }
        #endregion

        #region Public methods
        /// <summary> Makes a deep copy of the object. </summary>
        /// <returns> Returns object. </returns>
        [UsedImplicitly]
        public object Clone() {
            var def = new RhythmicMaterial {
                Name = this.Name
            };

            return def;
        }
        #endregion

        #region String representation
        /// <summary> String representation of the object. </summary>
        /// <returns> Returns value. </returns>
        public override string ToString() {
            var s = new StringBuilder();
            ////s.Append("\t" + this.HarmonicOrder.ToString(CultureInfo.CurrentCulture));
            return s.ToString();
        }
        #endregion

        #region Rhythmic producer - private
        /// <summary>
        /// Random Rhythmic Material.
        /// </summary>
        /// <param name="name">Name of material.</param>
        /// <param name="rhythmicStructs">Rhythmic Structs.</param>
        /// <param name="numberOfStructs">Number Of Structs.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        private static RhythmicMaterial RandomRhythmicMaterial(string name, Collection<RhythmicStructure> rhythmicStructs, int numberOfStructs) { //// byte rhythmicOrder,
            Contract.Requires(name != null);
            if (rhythmicStructs == null) {
                return null;
            }

            var rhythmicMaterial = new RhythmicMaterial { Name = name };
            for (var im = 0; im < numberOfStructs; im++) {
                var rs = ExtendCollection<RhythmicStructure>.GetRandomObject(rhythmicStructs);
                if (rs == null) {
                    continue;
                }

                var mrs = rs; //// Clone?
                rhythmicMaterial.Structures?.Add(mrs);
            }

            return rhythmicMaterial;
        }
        #endregion
    }
}